import fs from "fs";
const PATH = require('path');
import xlsx from 'xlsx';
import { quality, qualityName } from "../../shared/face/enums";

interface SkillDataItem {
    id: string;
    quality: any;
    name: string;
    desc: string;
    classType: any;
    data: any[];
    effect: any[];
    cooldown: number;
    type: any;
    targetType: any[];
    maxLevel?: number;
    [key: string]: any;
}

class JsonToXlsx {
    constructor() {
        // 确保输出目录存在
        this.ensureOutputDir();
    }

    private ensureOutputDir() {
        const outputDir = PATH.resolve('./xlsx/');
        if (!fs.existsSync(outputDir)) {
            fs.mkdirSync(outputDir, { recursive: true });
        }
    }

    /**
     * 将技能数据转换为xlsx格式
     * @param skills 技能数据数组
     * @param outputFileName 输出文件名（不含扩展名）
     */
    async convertSkillsToXlsx(skills: SkillDataItem[], outputFileName: string = 'skills') {
        try {
            // 创建类型行（第一行）
            const typeRow = this.createTypeRow(skills);
            
            // 创建数据行
            const dataRows = this.createDataRows(skills);
            
            // 合并所有行
            const allRows = [typeRow, ...dataRows];
            
            // 创建工作簿
            const workbook = xlsx.utils.book_new();
            
            // 创建工作表
            const worksheet = xlsx.utils.aoa_to_sheet(allRows);
            
            // 设置列宽
            this.setColumnWidths(worksheet, typeRow.length);
            
            // 将工作表添加到工作簿
            xlsx.utils.book_append_sheet(workbook, worksheet, 'skillTable');
            
            // 保存文件
            const outputPath = PATH.resolve('./xlsx/', `${outputFileName}.xlsx`);
            xlsx.writeFile(workbook, outputPath);
            
            console.log(`✅ 技能数据已成功转换为xlsx文件: ${outputPath}`);
            return outputPath;
            
        } catch (error) {
            console.error('❌ 转换失败:', error);
            throw error;
        }
    }

    /**
     * 创建类型行（第一行）
     */
    private createTypeRow(skills: SkillDataItem[]): string[] {
        const typeRow: string[] = [];
        
        // 基础字段类型
        typeRow.push('String'); // id
        typeRow.push('String'); // quality
        typeRow.push('String'); // name
        typeRow.push('String'); // desc
        typeRow.push('String'); // classType
        typeRow.push('Json');   // data
        typeRow.push('Json');   // effect
        typeRow.push('Num');    // cooldown
        typeRow.push('String'); // type
        typeRow.push('Json');   // targetType
        typeRow.push('Num');    // maxLevel
        
        // 动态字段类型（从data数组中的第一个元素推断）
        if (skills.length > 0 && skills[0].data && skills[0].data.length > 0) {
            const firstDataItem = skills[0].data[0];
            for (const key in firstDataItem) {
                if (key === 'levelUpBoost') {
                    typeRow.push('Json'); // levelUpBoost是对象
                } else if (typeof firstDataItem[key] === 'number') {
                    typeRow.push('Num');
                } else {
                    typeRow.push('String');
                }
            }
        }
        
        return typeRow;
    }

    /**
     * 创建数据行
     */
    private createDataRows(skills: SkillDataItem[]): any[][] {
        return skills.map(skill => {
            const row: any[] = [];
            
            // 基础字段
            row.push(`
id=${Object.values(quality)[skill.quality]}-${skill.name}
reName=${skill.name}
_desc=${skill.desc}
_type=${skill.type}
skillId=${skill.id}
maxLevel=${skill.maxLevel || 10}
` || '');
            return row;
        });
    }

    /**
     * 设置列宽
     */
    private setColumnWidths(worksheet: any, columnCount: number) {
        const columnWidths = [
            { wch: 15 }, // id
            { wch: 12 }, // quality
            { wch: 20 }, // name
            { wch: 40 }, // desc
            { wch: 15 }, // classType
            { wch: 50 }, // data
            { wch: 30 }, // effect
            { wch: 12 }, // cooldown
            { wch: 15 }, // type
            { wch: 30 }, // targetType
            { wch: 12 }, // maxLevel
        ];
        
        // 为动态字段设置默认列宽
        for (let i = columnWidths.length; i < columnCount; i++) {
            columnWidths.push({ wch: 15 });
        }
        
        worksheet['!cols'] = columnWidths;
    }

    /**
     * 更新现有xlsx文件中的skillTable工作区
     * @param skills 技能数据数组
     * @param xlsxFilePath xlsx文件路径
     */
    async updateSkillTableInExistingFile(skills: SkillDataItem[], xlsxFilePath: string = './xlsx/技能配置.xlsx') {
        try {
            console.log(`📖 读取现有文件: ${xlsxFilePath}`);
            
            // 检查文件是否存在
            if (!fs.existsSync(xlsxFilePath)) {
                throw new Error(`文件不存在: ${xlsxFilePath}`);
            }
            
            // 读取现有的xlsx文件
            const workbook = xlsx.readFile(xlsxFilePath);
            
            // 检查是否已存在skillTable工作区
            let existingWorksheet = null;
            if (workbook.SheetNames.includes('skillTable')) {
                console.log('🔄 更新现有的skillTable工作区...');
                existingWorksheet = workbook.Sheets['skillTable'];
            } else {
                console.log('➕ 创建新的skillTable工作区...');
            }
            
            // 创建新的skillTable工作表数据
            const dataRows = this.createDataRows(skills);
            const allRows = dataRows;
            
            // 创建工作表
            const worksheet = xlsx.utils.aoa_to_sheet(allRows);
            
            // 如果存在原有工作表，复制其格式设置
            if (existingWorksheet) {
                console.log('📋 保留原有格式设置...');
                
                // 复制列宽设置
                if (existingWorksheet['!cols']) {
                    worksheet['!cols'] = existingWorksheet['!cols'];
                }
                
                // 复制行高设置
                if (existingWorksheet['!rows']) {
                    worksheet['!rows'] = existingWorksheet['!rows'];
                }
                
                // 复制合并单元格设置
                if (existingWorksheet['!merges']) {
                    worksheet['!merges'] = existingWorksheet['!merges'];
                }
                
                // 复制页面设置
                if (existingWorksheet['!margins']) {
                    worksheet['!margins'] = existingWorksheet['!margins'];
                }
                
                // 复制打印设置
                if (existingWorksheet['!print']) {
                    worksheet['!print'] = existingWorksheet['!print'];
                }
                
                // 复制视图设置
                if (existingWorksheet['!views']) {
                    worksheet['!views'] = existingWorksheet['!views'];
                }
                
                // 复制条件格式
                if (existingWorksheet['!cf']) {
                    worksheet['!cf'] = existingWorksheet['!cf'];
                }
                
                // 复制数据验证
                if (existingWorksheet['!dv']) {
                    worksheet['!dv'] = existingWorksheet['!dv'];
                }
                
                // 复制样式信息（如果存在）
                if (existingWorksheet['!styles']) {
                    worksheet['!styles'] = existingWorksheet['!styles'];
                }
                
                // 复制主题信息（如果存在）
                if (existingWorksheet['!theme']) {
                    worksheet['!theme'] = existingWorksheet['!theme'];
                }
            } else {
                // 如果没有原有工作表，设置默认列宽
                this.setColumnWidths(worksheet, dataRows.length > 0 ? dataRows[0].length : 10);
            }
            
            // 更新工作簿中的工作表
            workbook.Sheets['skillTable'] = worksheet;
            
            // 保存更新后的文件
            xlsx.writeFile(workbook, xlsxFilePath);
            
            console.log(`✅ 成功更新 ${xlsxFilePath} 文件中的skillTable工作区`);
            console.log(`📊 更新了 ${skills.length} 个技能数据`);
            if (existingWorksheet) {
                console.log(`🎨 保留了原有的格式设置`);
            }
            
            return xlsxFilePath;
            
        } catch (error) {
            console.error('❌ 更新现有文件失败:', error);
            throw error;
        }
    }

    /**
     * 从技能配置文件读取数据并更新现有xlsx文件
     */
    async updateSkillTableFromFiles(xlsxFilePath: string = './xlsx/技能配置.xlsx') {
        try {
            const skillTypes = ['active', 'passive', 'aura'];
            const allSkills: SkillDataItem[] = [];
            
            for (const skillType of skillTypes) {
                const skillTypePath = PATH.resolve(__dirname, '../rpg/config/skills', skillType);
                
                if (fs.existsSync(skillTypePath)) {
                    const files = fs.readdirSync(skillTypePath);
                    
                    for (const file of files) {
                        if (file.endsWith('.ts') || file.endsWith('.js')) {
                            const filePath = PATH.resolve(skillTypePath, file);
                            console.log(`📖 读取技能文件: ${filePath}`);
                            
                            try {
                                // 动态导入模块
                                const module = await import(filePath);
                                const skillData = module.default || module;
                                
                                if (Array.isArray(skillData)) {
                                    allSkills.push(...skillData);
                                    console.log(`  ✅ 成功读取 ${skillData.length} 个技能`);
                                } else {
                                    console.log(`  ⚠️  文件格式不正确，期望数组格式`);
                                }
                            } catch (importError) {
                                console.log(`  ❌ 导入失败: ${importError}`);
                            }
                        }
                    }
                }
            }
            
            if (allSkills.length > 0) {
                console.log(`\n🎯 总共读取到 ${allSkills.length} 个技能`);
                await this.updateSkillTableInExistingFile(allSkills, xlsxFilePath);
            } else {
                console.log('❌ 没有读取到任何技能数据');
            }
            
        } catch (error) {
            console.error('❌ 更新技能表失败:', error);
        }
    }

    /**
     * 从JSON文件读取数据并转换
     */
    async convertFromJsonFile(jsonFilePath: string, outputFileName?: string) {
        try {
            if (!fs.existsSync(jsonFilePath)) {
                throw new Error(`JSON文件不存在: ${jsonFilePath}`);
            }
            
            const fileContent = fs.readFileSync(jsonFilePath, 'utf-8');
            const skills: SkillDataItem[] = JSON.parse(fileContent);
            
            if (!Array.isArray(skills)) {
                throw new Error('JSON文件格式不正确，期望数组格式');
            }
            
            const fileName = outputFileName || PATH.basename(jsonFilePath, '.json');
            await this.convertSkillsToXlsx(skills, fileName);
            
        } catch (error) {
            console.error('❌ 转换JSON文件失败:', error);
        }
    }
}

export default new JsonToXlsx(); 